/*
 * Copyright (c) 2023 huipei.x
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package cn.xphsc.kubernetes.core.query;
/**
 * {@link }
 * @author <a href="xiongpeih@163.com">huipei.x</a>
 * @description: Namespace Query
 * @since 1.0.0
 */
public class NamespaceQuery {
    /**
     * namespace object name and auth scope, such as for teams and projects (required
     */
    private  String namespace;
    /**
     * If &#39;true&#39;, then the output is pretty printed. (optional)
     */
    private String pretty;
    /**
     * allowWatchBookmarks requests watch events with type
     *  \&quot;BOOKMARK\&quot;. Servers that do not implement bookmarks may ignore this flag and
     *  bookmarks are sent at the server&#39;s discretion. Clients should not assume bookmarks are
     * returned at any specific interval, nor may they assume the server will send any BOOKMARK
     *  event during a session. If this is not a watch, this field is ignored. (optional)
     */
    private Boolean allowWatchBookmarks;
    /**
     * The continue option should be set when retrieving more results from the
     *   server. Since this value is server defined, clients may only use the continue value from a
     *  previous query result with identical query parameters (except for the value of continue)
     * and the server may reject a continue value it does not recognize. If the specified continue
     *  value is no longer valid whether due to expiration (generally five to fifteen minutes) or a
     *  configuration change on the server, the server will respond with a 410 ResourceExpired
     *  error together with a continue token. If the client needs a consistent list, it must
     *  restart their list without the continue field. Otherwise, the client may send another list
     *  request with the token received with the 410 error, the server will respond with a list
     *  starting from the next key, but from the latest snapshot, which is inconsistent from the
     *  previous list results - objects that are created, modified, or deleted after the first list
     * request will be included in the response, as long as their keys are after the \&quot;next
     *   key\&quot;. This field is not supported when watch is true. Clients may start a watch from
     *  the last resourceVersion value returned by the server and not miss any modifications.
     *   (optional)
     */
    private String _continue;
    /**
     * A selector to restrict the list of returned objects by their fields.
     *  Defaults to everything. (optional)
     */
    private String fieldSelector;
    /**
     *  A selector to restrict the list of returned objects by their labels.
     *  Defaults to everything. (optional)
     */
    private String labelSelector;
    /**
     * limit is a maximum number of responses to return for a list call. If more items
     *  exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value
     * that can be used with the same initial query to retrieve the next set of results. Setting a
     *  limit may return fewer than the requested amount of items (up to zero items) in the event
     *  all requested objects are filtered out and clients should only use the presence of the
     *  continue field to determine whether more results are available. Servers may choose not to
     *   support the limit argument and will return all of the available results. If limit is
     *   specified and the continue field is empty, clients may assume that no more results are
     *  available. This field is not supported if watch is true. The server guarantees that the
     *  objects returned when using continue will be identical to issuing a single list call
     * without a limit - that is, no objects created, modified, or deleted after the first request
     *  s issued will be included in any subsequent continued requests. This is sometimes referred
     * to as a consistent snapshot, and ensures that a client that is using limit to receive
     *  smaller chunks of a very large result can ensure they see all possible objects. If objects
     *  are updated during a chunked list the version of the object that was present at the time
     *   the first list result was calculated is returned. (optional)
     */
    private Integer limit;
    /**
     * resourceVersion sets a constraint on what resource versions a request
     * may be served from. See
     * https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.
     * Defaults to unset (optional)
     */
    private String resourceVersion;
    /**
     * resourceVersionMatch determines how resourceVersion is applied to
     * list calls. It is highly recommended that resourceVersionMatch be set for list calls where
     * resourceVersion is set See
     * https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.
     * Defaults to unset (optional)
     */
    private String resourceVersionMatch;
    /**
     * timeoutSeconds Timeout for the list/watch call. This limits the duration of the call,
     * regardless of any activity or inactivity. (optional)
     */
    private Integer timeoutSeconds;
    /**
     * Watch for changes to the described resources and return them as a stream of add,
     *  update, and remove notifications. Specify resourceVersion. (optional)
     */
    private Boolean watch;

    public static NamespaceQuery.Builder builder() {
        return new NamespaceQuery.Builder();
    }

    private NamespaceQuery(NamespaceQuery.Builder builder) {
        this.namespace=builder.namespace;
        this.pretty = builder.pretty;
        this.allowWatchBookmarks = builder.allowWatchBookmarks;
        this._continue = builder._continue;
        this.fieldSelector = builder.fieldSelector;
        this.labelSelector = builder.labelSelector;
        this.limit = builder.limit;
        this.resourceVersion = builder.resourceVersion;
        this.resourceVersionMatch = builder.resourceVersionMatch;
        this.timeoutSeconds = builder.timeoutSeconds;
        this.watch = builder.watch;

    }


    public static class Builder {
        private  String namespace;
        private String pretty;
        private Boolean allowWatchBookmarks;
        private String _continue;
        private String fieldSelector;
        private String labelSelector;
        private Integer limit;
        private String resourceVersion;
        private Integer timeoutSeconds;
        private String resourceVersionMatch;
        private Boolean watch;

        public Builder() {
        }
        /**
         * namespace object name and auth scope, such as for teams and projects (required
         */
        public <T> NamespaceQuery.Builder namespace(String namespace) {
            this.namespace = namespace;
            return this;
        }
        /**
         * If &#39;true&#39;, then the output is pretty printed. (optional)
         */
        public <T> NamespaceQuery.Builder pretty(String pretty) {
            this.pretty = pretty;
            return this;
        }
        /**
         * allowWatchBookmarks requests watch events with type
         *  \&quot;BOOKMARK\&quot;. Servers that do not implement bookmarks may ignore this flag and
         *  bookmarks are sent at the server&#39;s discretion. Clients should not assume bookmarks are
         * returned at any specific interval, nor may they assume the server will send any BOOKMARK
         *  event during a session. If this is not a watch, this field is ignored. (optional)
         */
        public <T> NamespaceQuery.Builder allowWatchBookmarks(boolean allowWatchBookmarks) {
            this.allowWatchBookmarks = allowWatchBookmarks;
            return this;
        }
        /**
         * The continue option should be set when retrieving more results from the
         *   server. Since this value is server defined, clients may only use the continue value from a
         *  previous query result with identical query parameters (except for the value of continue)
         * and the server may reject a continue value it does not recognize. If the specified continue
         *  value is no longer valid whether due to expiration (generally five to fifteen minutes) or a
         *  configuration change on the server, the server will respond with a 410 ResourceExpired
         *  error together with a continue token. If the client needs a consistent list, it must
         *  restart their list without the continue field. Otherwise, the client may send another list
         *  request with the token received with the 410 error, the server will respond with a list
         *  starting from the next key, but from the latest snapshot, which is inconsistent from the
         *  previous list results - objects that are created, modified, or deleted after the first list
         * request will be included in the response, as long as their keys are after the \&quot;next
         *   key\&quot;. This field is not supported when watch is true. Clients may start a watch from
         *  the last resourceVersion value returned by the server and not miss any modifications.
         *   (optional)
         */
        public <T> NamespaceQuery.Builder _continue(String _continue) {
            this._continue = _continue;
            return this;
        }

        public <T> NamespaceQuery.Builder fieldSelector(String fieldSelector) {
            this.fieldSelector = fieldSelector;
            return this;
        }
        /**
         *  A selector to restrict the list of returned objects by their labels.
         *  Defaults to everything. (optional)
         */
        public <T> NamespaceQuery.Builder labelSelector(String labelSelector) {
            this.labelSelector = labelSelector;
            return this;
        }
        /**
         * resourceVersion sets a constraint on what resource versions a request
         * may be served from. See
         * https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.
         * Defaults to unset (optional)
         */
        public <T> NamespaceQuery.Builder resourceVersion(String resourceVersion) {
            this.resourceVersion = resourceVersion;
            return this;
        }
        /**
         * resourceVersionMatch determines how resourceVersion is applied to
         * list calls. It is highly recommended that resourceVersionMatch be set for list calls where
         * resourceVersion is set See
         * https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.
         * Defaults to unset (optional)
         */
        public <T> NamespaceQuery.Builder resourceVersionMatch(String resourceVersionMatch) {
            this.resourceVersionMatch = resourceVersionMatch;
            return this;
        }
        /**
         * limit is a maximum number of responses to return for a list call. If more items
         *  exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value
         * that can be used with the same initial query to retrieve the next set of results. Setting a
         *  limit may return fewer than the requested amount of items (up to zero items) in the event
         *  all requested objects are filtered out and clients should only use the presence of the
         *  continue field to determine whether more results are available. Servers may choose not to
         *   support the limit argument and will return all of the available results. If limit is
         *   specified and the continue field is empty, clients may assume that no more results are
         *  available. This field is not supported if watch is true. The server guarantees that the
         *  objects returned when using continue will be identical to issuing a single list call
         * without a limit - that is, no objects created, modified, or deleted after the first request
         *  s issued will be included in any subsequent continued requests. This is sometimes referred
         * to as a consistent snapshot, and ensures that a client that is using limit to receive
         *  smaller chunks of a very large result can ensure they see all possible objects. If objects
         *  are updated during a chunked list the version of the object that was present at the time
         *   the first list result was calculated is returned. (optional)
         */
        public <T> NamespaceQuery.Builder limit(Integer limit) {
            this.limit = limit;
            return this;
        }
        /**
         * timeoutSeconds Timeout for the list/watch call. This limits the duration of the call,
         * regardless of any activity or inactivity. (optional)
         */
        public <T> NamespaceQuery.Builder timeoutSeconds(Integer timeoutSeconds) {
            this.timeoutSeconds = timeoutSeconds;
            return this;
        }
        /**
         * Watch for changes to the described resources and return them as a stream of add,
         *  update, and remove notifications. Specify resourceVersion. (optional)
         */
        public <T> NamespaceQuery.Builder watch(Boolean watch) {
            this.watch = watch;
            return this;
        }





        public NamespaceQuery build() {
            return new NamespaceQuery(this);
        }
    }

    public String namespace() {
        return namespace;
    }

    public String pretty() {
        return pretty;
    }

    public Boolean allowWatchBookmarks() {
        return allowWatchBookmarks;
    }

    public String _continue() {
        return _continue;
    }

    public String fieldSelector() {
        return fieldSelector;
    }

    public String labelSelector() {
        return labelSelector;
    }

    public Integer limit() {
        return limit;
    }

    public String resourceVersion() {
        return resourceVersion;
    }

    public String resourceVersionMatch() {
        return resourceVersionMatch;
    }


    public Integer timeoutSeconds() {
        return timeoutSeconds;
    }

    public Boolean watch() {
        return watch;
    }
}
